Thematic review and analysis of grounded theory application in software engineering

We present metacodes, a new concept to guide grounded theory (GT) research in software engineering. Metacodes are high level codes that can help software engineering researchers guide the data coding process. Metacodes are constructed in the course of analyzing software engineering papers that use grounded theory as a research methodology. We performed a high level analysis to discover common themes in such papers and discovered that GT had been applied primarily in three software engineering disciplines: agile development processes, geographically distributed software development, and requirements engineering. For each category, we collected and analyzed all grounded theory codes and created, following a GT analysis process, what we call metacodes that can be used to drive further theory building. This paper surveys the use of grounded theory in software engineering and presents an overview of successes and challenges of applying this research methodology

Model Driven Software Engineering in Education: A Multi-Case Study on Perception of Tools and UML

While several benefits of using models in software engineering have been observed in practice, the adoption of modeling remains low. Multiple challenges of using models, especially related to tools, have been reported both for industrial use and for education. However, there is a lack of systematic, empirical investigations of the challenges in modeling education and their relation to industrial challenges. Therefore, we conducted a multiple-case study with two cases, in the U.S and Sweden, focusing on students\u27 perceptions towards tooling and UML in education. Our data collected from 369 student evaluation surveys, enriched with qualitative data, shows that the students\u27 perception of modeling tools depends not only on the complexity of tools, but rather on multiple contextual factors, including tool characteristics, scope of course and project contents, nature of the required models, and the tools\u27 role in generating executable artifacts. We conclude that there is a need for tailoring modeling tools for education beyond focusing on simplification and usability. Furthermore, due to the broad diversity within the modeling domain, there is a need for adapting the use of tools to the specific curriculum and course learning objectives

Modeling Practices in Open Source Software

Part 1: Full Papers - Practices and MethodsInternational audienceIt is widely accepted that modeling in software engineering increases productivity and results in better code quality. Yet, modeling adoption remains low. The open source community, in particular, remains almost entirely code centric. In this paper, we explore the reasons behind such limited adoption of modeling practices among open source developers. We highlight characteristics of modeling tools that would encourage their adoption. We propose Umple as a solution where both modeling and coding elements are treated uniformly. In this approach, models can be manipulated textually and code can be edited visually. We also report on the Umple compiler itself as a case study of an open source project where contributors, using the above approach, have and continue to routinely commit code and model over a number of years

Theoretical Explanation of Recent Empirically Successful Code Quality Metrics

Millions of lines of code are written every day, and it is not practically possible to perfectly thoroughly test all this code on all possible situations. In practice, we need to be able to separate codes which are more probable to contain bugs -- and which thus need to be tested more thoroughly -- from codes which are less probable to contain flaws. Several numerical characteristics -- known as code quality metrics -- have been proposed for this separation. Recently, a new efficient class of code quality metrics have been proposed, based on the idea to assign consequent integers to different levels of complexity and vulnerability: we assign 1 to the simplest level, 2 to the next simplest level, etc. The resulting numbers are then combined -- if needed, with appropriate weights. In this paper, we provide a theoretical explanation for the above idea

Requirement Traceability: A Model-Based Approach

Abstract-Requirements tractability remains challenging, particularly in the prevalence of code centric approaches. Similarly, within the emerging model centric paradigm, requirements traceability is addressed only to a limited extent. To facilitate such traceability, we call for representing requirements as first class entities in the emerging paradigm of model-oriented programming. This has the objective of enabling software developers, modelers, and business analysts to manipulate requirements entities as textual model and code elements. To illustrate the feasibility of such an approach, we propose a Requirement-Oriented Modeling and Programming Language (ROMPL) that demonstrates how modeling abstractions can be utilized to manage the behavior and relationships of key requirements entities